home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / scripts / kconfig / lex.zconf.c_shipped < prev    next >
Encoding:
Text File  |  2008-12-24  |  56.5 KB  |  2,414 lines
  1.  
  2. #line 3 "scripts/kconfig/lex.zconf.c"
  3.  
  4. #define  YY_INT_ALIGNED short int
  5.  
  6. /* A lexical scanner generated by flex */
  7.  
  8. #define yy_create_buffer zconf_create_buffer
  9. #define yy_delete_buffer zconf_delete_buffer
  10. #define yy_flex_debug zconf_flex_debug
  11. #define yy_init_buffer zconf_init_buffer
  12. #define yy_flush_buffer zconf_flush_buffer
  13. #define yy_load_buffer_state zconf_load_buffer_state
  14. #define yy_switch_to_buffer zconf_switch_to_buffer
  15. #define yyin zconfin
  16. #define yyleng zconfleng
  17. #define yylex zconflex
  18. #define yylineno zconflineno
  19. #define yyout zconfout
  20. #define yyrestart zconfrestart
  21. #define yytext zconftext
  22. #define yywrap zconfwrap
  23. #define yyalloc zconfalloc
  24. #define yyrealloc zconfrealloc
  25. #define yyfree zconffree
  26.  
  27. #define FLEX_SCANNER
  28. #define YY_FLEX_MAJOR_VERSION 2
  29. #define YY_FLEX_MINOR_VERSION 5
  30. #define YY_FLEX_SUBMINOR_VERSION 35
  31. #if YY_FLEX_SUBMINOR_VERSION > 0
  32. #define FLEX_BETA
  33. #endif
  34.  
  35. /* First, we deal with  platform-specific or compiler-specific issues. */
  36.  
  37. /* begin standard C headers. */
  38. #include <stdio.h>
  39. #include <string.h>
  40. #include <errno.h>
  41. #include <stdlib.h>
  42.  
  43. /* end standard C headers. */
  44.  
  45. /* flex integer type definitions */
  46.  
  47. #ifndef FLEXINT_H
  48. #define FLEXINT_H
  49.  
  50. /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  51.  
  52. #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  53.  
  54. /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  55.  * if you want the limit (max/min) macros for int types. 
  56.  */
  57. #ifndef __STDC_LIMIT_MACROS
  58. #define __STDC_LIMIT_MACROS 1
  59. #endif
  60.  
  61. #include <inttypes.h>
  62. typedef int8_t flex_int8_t;
  63. typedef uint8_t flex_uint8_t;
  64. typedef int16_t flex_int16_t;
  65. typedef uint16_t flex_uint16_t;
  66. typedef int32_t flex_int32_t;
  67. typedef uint32_t flex_uint32_t;
  68. #else
  69. typedef signed char flex_int8_t;
  70. typedef short int flex_int16_t;
  71. typedef int flex_int32_t;
  72. typedef unsigned char flex_uint8_t; 
  73. typedef unsigned short int flex_uint16_t;
  74. typedef unsigned int flex_uint32_t;
  75.  
  76. /* Limits of integral types. */
  77. #ifndef INT8_MIN
  78. #define INT8_MIN               (-128)
  79. #endif
  80. #ifndef INT16_MIN
  81. #define INT16_MIN              (-32767-1)
  82. #endif
  83. #ifndef INT32_MIN
  84. #define INT32_MIN              (-2147483647-1)
  85. #endif
  86. #ifndef INT8_MAX
  87. #define INT8_MAX               (127)
  88. #endif
  89. #ifndef INT16_MAX
  90. #define INT16_MAX              (32767)
  91. #endif
  92. #ifndef INT32_MAX
  93. #define INT32_MAX              (2147483647)
  94. #endif
  95. #ifndef UINT8_MAX
  96. #define UINT8_MAX              (255U)
  97. #endif
  98. #ifndef UINT16_MAX
  99. #define UINT16_MAX             (65535U)
  100. #endif
  101. #ifndef UINT32_MAX
  102. #define UINT32_MAX             (4294967295U)
  103. #endif
  104.  
  105. #endif /* ! C99 */
  106.  
  107. #endif /* ! FLEXINT_H */
  108.  
  109. #ifdef __cplusplus
  110.  
  111. /* The "const" storage-class-modifier is valid. */
  112. #define YY_USE_CONST
  113.  
  114. #else    /* ! __cplusplus */
  115.  
  116. /* C99 requires __STDC__ to be defined as 1. */
  117. #if defined (__STDC__)
  118.  
  119. #define YY_USE_CONST
  120.  
  121. #endif    /* defined (__STDC__) */
  122. #endif    /* ! __cplusplus */
  123.  
  124. #ifdef YY_USE_CONST
  125. #define yyconst const
  126. #else
  127. #define yyconst
  128. #endif
  129.  
  130. /* Returned upon end-of-file. */
  131. #define YY_NULL 0
  132.  
  133. /* Promotes a possibly negative, possibly signed char to an unsigned
  134.  * integer for use as an array index.  If the signed char is negative,
  135.  * we want to instead treat it as an 8-bit unsigned char, hence the
  136.  * double cast.
  137.  */
  138. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  139.  
  140. /* Enter a start condition.  This macro really ought to take a parameter,
  141.  * but we do it the disgusting crufty way forced on us by the ()-less
  142.  * definition of BEGIN.
  143.  */
  144. #define BEGIN (yy_start) = 1 + 2 *
  145.  
  146. /* Translate the current start state into a value that can be later handed
  147.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  148.  * compatibility.
  149.  */
  150. #define YY_START (((yy_start) - 1) / 2)
  151. #define YYSTATE YY_START
  152.  
  153. /* Action number for EOF rule of a given start state. */
  154. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  155.  
  156. /* Special action meaning "start processing a new file". */
  157. #define YY_NEW_FILE zconfrestart(zconfin  )
  158.  
  159. #define YY_END_OF_BUFFER_CHAR 0
  160.  
  161. /* Size of default input buffer. */
  162. #ifndef YY_BUF_SIZE
  163. #define YY_BUF_SIZE 16384
  164. #endif
  165.  
  166. /* The state buf must be large enough to hold one state per character in the main buffer.
  167.  */
  168. #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
  169.  
  170. #ifndef YY_TYPEDEF_YY_BUFFER_STATE
  171. #define YY_TYPEDEF_YY_BUFFER_STATE
  172. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  173. #endif
  174.  
  175. extern int zconfleng;
  176.  
  177. extern FILE *zconfin, *zconfout;
  178.  
  179. #define EOB_ACT_CONTINUE_SCAN 0
  180. #define EOB_ACT_END_OF_FILE 1
  181. #define EOB_ACT_LAST_MATCH 2
  182.  
  183.     #define YY_LESS_LINENO(n)
  184.     
  185. /* Return all but the first "n" matched characters back to the input stream. */
  186. #define yyless(n) \
  187.     do \
  188.         { \
  189.         /* Undo effects of setting up zconftext. */ \
  190.         int yyless_macro_arg = (n); \
  191.         YY_LESS_LINENO(yyless_macro_arg);\
  192.         *yy_cp = (yy_hold_char); \
  193.         YY_RESTORE_YY_MORE_OFFSET \
  194.         (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
  195.         YY_DO_BEFORE_ACTION; /* set up zconftext again */ \
  196.         } \
  197.     while ( 0 )
  198.  
  199. #define unput(c) yyunput( c, (yytext_ptr)  )
  200.  
  201. #ifndef YY_TYPEDEF_YY_SIZE_T
  202. #define YY_TYPEDEF_YY_SIZE_T
  203. typedef size_t yy_size_t;
  204. #endif
  205.  
  206. #ifndef YY_STRUCT_YY_BUFFER_STATE
  207. #define YY_STRUCT_YY_BUFFER_STATE
  208. struct yy_buffer_state
  209.     {
  210.     FILE *yy_input_file;
  211.  
  212.     char *yy_ch_buf;        /* input buffer */
  213.     char *yy_buf_pos;        /* current position in input buffer */
  214.  
  215.     /* Size of input buffer in bytes, not including room for EOB
  216.      * characters.
  217.      */
  218.     yy_size_t yy_buf_size;
  219.  
  220.     /* Number of characters read into yy_ch_buf, not including EOB
  221.      * characters.
  222.      */
  223.     int yy_n_chars;
  224.  
  225.     /* Whether we "own" the buffer - i.e., we know we created it,
  226.      * and can realloc() it to grow it, and should free() it to
  227.      * delete it.
  228.      */
  229.     int yy_is_our_buffer;
  230.  
  231.     /* Whether this is an "interactive" input source; if so, and
  232.      * if we're using stdio for input, then we want to use getc()
  233.      * instead of fread(), to make sure we stop fetching input after
  234.      * each newline.
  235.      */
  236.     int yy_is_interactive;
  237.  
  238.     /* Whether we're considered to be at the beginning of a line.
  239.      * If so, '^' rules will be active on the next match, otherwise
  240.      * not.
  241.      */
  242.     int yy_at_bol;
  243.  
  244.     int yy_bs_lineno; /**< The line count. */
  245.     int yy_bs_column; /**< The column count. */
  246.     
  247.     /* Whether to try to fill the input buffer when we reach the
  248.      * end of it.
  249.      */
  250.     int yy_fill_buffer;
  251.  
  252.     int yy_buffer_status;
  253.  
  254. #define YY_BUFFER_NEW 0
  255. #define YY_BUFFER_NORMAL 1
  256.     /* When an EOF's been seen but there's still some text to process
  257.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  258.      * shouldn't try reading from the input source any more.  We might
  259.      * still have a bunch of tokens to match, though, because of
  260.      * possible backing-up.
  261.      *
  262.      * When we actually see the EOF, we change the status to "new"
  263.      * (via zconfrestart()), so that the user can continue scanning by
  264.      * just pointing zconfin at a new input file.
  265.      */
  266. #define YY_BUFFER_EOF_PENDING 2
  267.  
  268.     };
  269. #endif /* !YY_STRUCT_YY_BUFFER_STATE */
  270.  
  271. /* Stack of input buffers. */
  272. static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
  273. static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
  274. static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
  275.  
  276. /* We provide macros for accessing buffer states in case in the
  277.  * future we want to put the buffer states in a more general
  278.  * "scanner state".
  279.  *
  280.  * Returns the top of the stack, or NULL.
  281.  */
  282. #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
  283.                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
  284.                           : NULL)
  285.  
  286. /* Same as previous macro, but useful when we know that the buffer stack is not
  287.  * NULL or when we need an lvalue. For internal use only.
  288.  */
  289. #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
  290.  
  291. /* yy_hold_char holds the character lost when zconftext is formed. */
  292. static char yy_hold_char;
  293. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  294. int zconfleng;
  295.  
  296. /* Points to current character in buffer. */
  297. static char *yy_c_buf_p = (char *) 0;
  298. static int yy_init = 0;        /* whether we need to initialize */
  299. static int yy_start = 0;    /* start state number */
  300.  
  301. /* Flag which is used to allow zconfwrap()'s to do buffer switches
  302.  * instead of setting up a fresh zconfin.  A bit of a hack ...
  303.  */
  304. static int yy_did_buffer_switch_on_eof;
  305.  
  306. void zconfrestart (FILE *input_file  );
  307. void zconf_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
  308. YY_BUFFER_STATE zconf_create_buffer (FILE *file,int size  );
  309. void zconf_delete_buffer (YY_BUFFER_STATE b  );
  310. void zconf_flush_buffer (YY_BUFFER_STATE b  );
  311. void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer  );
  312. void zconfpop_buffer_state (void );
  313.  
  314. static void zconfensure_buffer_stack (void );
  315. static void zconf_load_buffer_state (void );
  316. static void zconf_init_buffer (YY_BUFFER_STATE b,FILE *file  );
  317.  
  318. #define YY_FLUSH_BUFFER zconf_flush_buffer(YY_CURRENT_BUFFER )
  319.  
  320. YY_BUFFER_STATE zconf_scan_buffer (char *base,yy_size_t size  );
  321. YY_BUFFER_STATE zconf_scan_string (yyconst char *yy_str  );
  322. YY_BUFFER_STATE zconf_scan_bytes (yyconst char *bytes,int len  );
  323.  
  324. void *zconfalloc (yy_size_t  );
  325. void *zconfrealloc (void *,yy_size_t  );
  326. void zconffree (void *  );
  327.  
  328. #define yy_new_buffer zconf_create_buffer
  329.  
  330. #define yy_set_interactive(is_interactive) \
  331.     { \
  332.     if ( ! YY_CURRENT_BUFFER ){ \
  333.         zconfensure_buffer_stack (); \
  334.         YY_CURRENT_BUFFER_LVALUE =    \
  335.             zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
  336.     } \
  337.     YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
  338.     }
  339.  
  340. #define yy_set_bol(at_bol) \
  341.     { \
  342.     if ( ! YY_CURRENT_BUFFER ){\
  343.         zconfensure_buffer_stack (); \
  344.         YY_CURRENT_BUFFER_LVALUE =    \
  345.             zconf_create_buffer(zconfin,YY_BUF_SIZE ); \
  346.     } \
  347.     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  348.     }
  349.  
  350. #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
  351.  
  352. /* Begin user sect3 */
  353.  
  354. #define zconfwrap(n) 1
  355. #define YY_SKIP_YYWRAP
  356.  
  357. typedef unsigned char YY_CHAR;
  358.  
  359. FILE *zconfin = (FILE *) 0, *zconfout = (FILE *) 0;
  360.  
  361. typedef int yy_state_type;
  362.  
  363. extern int zconflineno;
  364.  
  365. int zconflineno = 1;
  366.  
  367. extern char *zconftext;
  368. #define yytext_ptr zconftext
  369. static yyconst flex_int16_t yy_nxt[][17] =
  370.     {
  371.     {
  372.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  373.         0,    0,    0,    0,    0,    0,    0
  374.     },
  375.  
  376.     {
  377.        11,   12,   13,   14,   12,   12,   15,   12,   12,   12,
  378.        12,   12,   12,   12,   12,   12,   12
  379.     },
  380.  
  381.     {
  382.        11,   12,   13,   14,   12,   12,   15,   12,   12,   12,
  383.        12,   12,   12,   12,   12,   12,   12
  384.     },
  385.  
  386.     {
  387.        11,   16,   16,   17,   16,   16,   16,   16,   16,   16,
  388.        16,   16,   16,   18,   16,   16,   16
  389.     },
  390.  
  391.     {
  392.        11,   16,   16,   17,   16,   16,   16,   16,   16,   16,
  393.        16,   16,   16,   18,   16,   16,   16
  394.  
  395.     },
  396.  
  397.     {
  398.        11,   19,   20,   21,   19,   19,   19,   19,   19,   19,
  399.        19,   19,   19,   19,   19,   19,   19
  400.     },
  401.  
  402.     {
  403.        11,   19,   20,   21,   19,   19,   19,   19,   19,   19,
  404.        19,   19,   19,   19,   19,   19,   19
  405.     },
  406.  
  407.     {
  408.        11,   22,   22,   23,   22,   24,   22,   22,   24,   22,
  409.        22,   22,   22,   22,   22,   25,   22
  410.     },
  411.  
  412.     {
  413.        11,   22,   22,   23,   22,   24,   22,   22,   24,   22,
  414.        22,   22,   22,   22,   22,   25,   22
  415.     },
  416.  
  417.     {
  418.        11,   26,   26,   27,   28,   29,   30,   31,   29,   32,
  419.        33,   34,   35,   35,   36,   37,   38
  420.  
  421.     },
  422.  
  423.     {
  424.        11,   26,   26,   27,   28,   29,   30,   31,   29,   32,
  425.        33,   34,   35,   35,   36,   37,   38
  426.     },
  427.  
  428.     {
  429.       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
  430.       -11,  -11,  -11,  -11,  -11,  -11,  -11
  431.     },
  432.  
  433.     {
  434.        11,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
  435.       -12,  -12,  -12,  -12,  -12,  -12,  -12
  436.     },
  437.  
  438.     {
  439.        11,  -13,   39,   40,  -13,  -13,   41,  -13,  -13,  -13,
  440.       -13,  -13,  -13,  -13,  -13,  -13,  -13
  441.     },
  442.  
  443.     {
  444.        11,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
  445.       -14,  -14,  -14,  -14,  -14,  -14,  -14
  446.  
  447.     },
  448.  
  449.     {
  450.        11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
  451.        42,   42,   42,   42,   42,   42,   42
  452.     },
  453.  
  454.     {
  455.        11,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
  456.       -16,  -16,  -16,  -16,  -16,  -16,  -16
  457.     },
  458.  
  459.     {
  460.        11,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
  461.       -17,  -17,  -17,  -17,  -17,  -17,  -17
  462.     },
  463.  
  464.     {
  465.        11,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
  466.       -18,  -18,  -18,   44,  -18,  -18,  -18
  467.     },
  468.  
  469.     {
  470.        11,   45,   45,  -19,   45,   45,   45,   45,   45,   45,
  471.        45,   45,   45,   45,   45,   45,   45
  472.  
  473.     },
  474.  
  475.     {
  476.        11,  -20,   46,   47,  -20,  -20,  -20,  -20,  -20,  -20,
  477.       -20,  -20,  -20,  -20,  -20,  -20,  -20
  478.     },
  479.  
  480.     {
  481.        11,   48,  -21,  -21,   48,   48,   48,   48,   48,   48,
  482.        48,   48,   48,   48,   48,   48,   48
  483.     },
  484.  
  485.     {
  486.        11,   49,   49,   50,   49,  -22,   49,   49,  -22,   49,
  487.        49,   49,   49,   49,   49,  -22,   49
  488.     },
  489.  
  490.     {
  491.        11,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
  492.       -23,  -23,  -23,  -23,  -23,  -23,  -23
  493.     },
  494.  
  495.     {
  496.        11,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
  497.       -24,  -24,  -24,  -24,  -24,  -24,  -24
  498.  
  499.     },
  500.  
  501.     {
  502.        11,   51,   51,   52,   51,   51,   51,   51,   51,   51,
  503.        51,   51,   51,   51,   51,   51,   51
  504.     },
  505.  
  506.     {
  507.        11,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
  508.       -26,  -26,  -26,  -26,  -26,  -26,  -26
  509.     },
  510.  
  511.     {
  512.        11,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
  513.       -27,  -27,  -27,  -27,  -27,  -27,  -27
  514.     },
  515.  
  516.     {
  517.        11,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
  518.       -28,  -28,  -28,  -28,   53,  -28,  -28
  519.     },
  520.  
  521.     {
  522.        11,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
  523.       -29,  -29,  -29,  -29,  -29,  -29,  -29
  524.  
  525.     },
  526.  
  527.     {
  528.        11,   54,   54,  -30,   54,   54,   54,   54,   54,   54,
  529.        54,   54,   54,   54,   54,   54,   54
  530.     },
  531.  
  532.     {
  533.        11,  -31,  -31,  -31,  -31,  -31,  -31,   55,  -31,  -31,
  534.       -31,  -31,  -31,  -31,  -31,  -31,  -31
  535.     },
  536.  
  537.     {
  538.        11,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
  539.       -32,  -32,  -32,  -32,  -32,  -32,  -32
  540.     },
  541.  
  542.     {
  543.        11,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
  544.       -33,  -33,  -33,  -33,  -33,  -33,  -33
  545.     },
  546.  
  547.     {
  548.        11,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
  549.       -34,   56,   57,   57,  -34,  -34,  -34
  550.  
  551.     },
  552.  
  553.     {
  554.        11,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
  555.       -35,   57,   57,   57,  -35,  -35,  -35
  556.     },
  557.  
  558.     {
  559.        11,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
  560.       -36,  -36,  -36,  -36,  -36,  -36,  -36
  561.     },
  562.  
  563.     {
  564.        11,  -37,  -37,   58,  -37,  -37,  -37,  -37,  -37,  -37,
  565.       -37,  -37,  -37,  -37,  -37,  -37,  -37
  566.     },
  567.  
  568.     {
  569.        11,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
  570.       -38,  -38,  -38,  -38,  -38,  -38,   59
  571.     },
  572.  
  573.     {
  574.        11,  -39,   39,   40,  -39,  -39,   41,  -39,  -39,  -39,
  575.       -39,  -39,  -39,  -39,  -39,  -39,  -39
  576.  
  577.     },
  578.  
  579.     {
  580.        11,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
  581.       -40,  -40,  -40,  -40,  -40,  -40,  -40
  582.     },
  583.  
  584.     {
  585.        11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
  586.        42,   42,   42,   42,   42,   42,   42
  587.     },
  588.  
  589.     {
  590.        11,   42,   42,   43,   42,   42,   42,   42,   42,   42,
  591.        42,   42,   42,   42,   42,   42,   42
  592.     },
  593.  
  594.     {
  595.        11,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
  596.       -43,  -43,  -43,  -43,  -43,  -43,  -43
  597.     },
  598.  
  599.     {
  600.        11,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
  601.       -44,  -44,  -44,   44,  -44,  -44,  -44
  602.  
  603.     },
  604.  
  605.     {
  606.        11,   45,   45,  -45,   45,   45,   45,   45,   45,   45,
  607.        45,   45,   45,   45,   45,   45,   45
  608.     },
  609.  
  610.     {
  611.        11,  -46,   46,   47,  -46,  -46,  -46,  -46,  -46,  -46,
  612.       -46,  -46,  -46,  -46,  -46,  -46,  -46
  613.     },
  614.  
  615.     {
  616.        11,   48,  -47,  -47,   48,   48,   48,   48,   48,   48,
  617.        48,   48,   48,   48,   48,   48,   48
  618.     },
  619.  
  620.     {
  621.        11,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
  622.       -48,  -48,  -48,  -48,  -48,  -48,  -48
  623.     },
  624.  
  625.     {
  626.        11,   49,   49,   50,   49,  -49,   49,   49,  -49,   49,
  627.        49,   49,   49,   49,   49,  -49,   49
  628.  
  629.     },
  630.  
  631.     {
  632.        11,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
  633.       -50,  -50,  -50,  -50,  -50,  -50,  -50
  634.     },
  635.  
  636.     {
  637.        11,  -51,  -51,   52,  -51,  -51,  -51,  -51,  -51,  -51,
  638.       -51,  -51,  -51,  -51,  -51,  -51,  -51
  639.     },
  640.  
  641.     {
  642.        11,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
  643.       -52,  -52,  -52,  -52,  -52,  -52,  -52
  644.     },
  645.  
  646.     {
  647.        11,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
  648.       -53,  -53,  -53,  -53,  -53,  -53,  -53
  649.     },
  650.  
  651.     {
  652.        11,   54,   54,  -54,   54,   54,   54,   54,   54,   54,
  653.        54,   54,   54,   54,   54,   54,   54
  654.  
  655.     },
  656.  
  657.     {
  658.        11,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
  659.       -55,  -55,  -55,  -55,  -55,  -55,  -55
  660.     },
  661.  
  662.     {
  663.        11,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
  664.       -56,   60,   57,   57,  -56,  -56,  -56
  665.     },
  666.  
  667.     {
  668.        11,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
  669.       -57,   57,   57,   57,  -57,  -57,  -57
  670.     },
  671.  
  672.     {
  673.        11,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
  674.       -58,  -58,  -58,  -58,  -58,  -58,  -58
  675.     },
  676.  
  677.     {
  678.        11,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
  679.       -59,  -59,  -59,  -59,  -59,  -59,  -59
  680.  
  681.     },
  682.  
  683.     {
  684.        11,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
  685.       -60,   57,   57,   57,  -60,  -60,  -60
  686.     },
  687.  
  688.     } ;
  689.  
  690. static yy_state_type yy_get_previous_state (void );
  691. static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
  692. static int yy_get_next_buffer (void );
  693. static void yy_fatal_error (yyconst char msg[]  );
  694.  
  695. /* Done after the current pattern has been matched and before the
  696.  * corresponding action - sets up zconftext.
  697.  */
  698. #define YY_DO_BEFORE_ACTION \
  699.     (yytext_ptr) = yy_bp; \
  700.     zconfleng = (size_t) (yy_cp - yy_bp); \
  701.     (yy_hold_char) = *yy_cp; \
  702.     *yy_cp = '\0'; \
  703.     (yy_c_buf_p) = yy_cp;
  704.  
  705. #define YY_NUM_RULES 33
  706. #define YY_END_OF_BUFFER 34
  707. /* This struct is not used in this scanner,
  708.    but its presence is necessary. */
  709. struct yy_trans_info
  710.     {
  711.     flex_int32_t yy_verify;
  712.     flex_int32_t yy_nxt;
  713.     };
  714. static yyconst flex_int16_t yy_accept[61] =
  715.     {   0,
  716.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  717.        34,    5,    4,    2,    3,    7,    8,    6,   32,   29,
  718.        31,   24,   28,   27,   26,   22,   17,   13,   16,   20,
  719.        22,   11,   12,   19,   19,   14,   22,   22,    4,    2,
  720.         3,    3,    1,    6,   32,   29,   31,   30,   24,   23,
  721.        26,   25,   15,   20,    9,   19,   19,   21,   10,   18
  722.     } ;
  723.  
  724. static yyconst flex_int32_t yy_ec[256] =
  725.     {   0,
  726.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  727.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  728.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  729.         1,    2,    4,    5,    6,    1,    1,    7,    8,    9,
  730.        10,    1,    1,    1,   11,   12,   12,   13,   13,   13,
  731.        13,   13,   13,   13,   13,   13,   13,    1,    1,    1,
  732.        14,    1,    1,    1,   13,   13,   13,   13,   13,   13,
  733.        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
  734.        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
  735.         1,   15,    1,    1,   13,    1,   13,   13,   13,   13,
  736.  
  737.        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
  738.        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
  739.        13,   13,    1,   16,    1,    1,    1,    1,    1,    1,
  740.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  741.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  742.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  743.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  744.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  745.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  746.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  747.  
  748.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  749.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  750.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  751.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  752.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  753.         1,    1,    1,    1,    1
  754.     } ;
  755.  
  756. extern int zconf_flex_debug;
  757. int zconf_flex_debug = 0;
  758.  
  759. /* The intent behind this definition is that it'll catch
  760.  * any uses of REJECT which flex missed.
  761.  */
  762. #define REJECT reject_used_but_not_detected
  763. #define yymore() yymore_used_but_not_detected
  764. #define YY_MORE_ADJ 0
  765. #define YY_RESTORE_YY_MORE_OFFSET
  766. char *zconftext;
  767. #define YY_NO_INPUT 1
  768.  
  769. /*
  770.  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  771.  * Released under the terms of the GNU GPL v2.0.
  772.  */
  773.  
  774. #include <limits.h>
  775. #include <stdio.h>
  776. #include <stdlib.h>
  777. #include <string.h>
  778. #include <unistd.h>
  779.  
  780. #define LKC_DIRECT_LINK
  781. #include "lkc.h"
  782.  
  783. #define START_STRSIZE    16
  784.  
  785. static struct {
  786.     struct file *file;
  787.     int lineno;
  788. } current_pos;
  789.  
  790. static char *text;
  791. static int text_size, text_asize;
  792.  
  793. struct buffer {
  794.         struct buffer *parent;
  795.         YY_BUFFER_STATE state;
  796. };
  797.  
  798. struct buffer *current_buf;
  799.  
  800. static int last_ts, first_ts;
  801.  
  802. static void zconf_endhelp(void);
  803. static void zconf_endfile(void);
  804.  
  805. void new_string(void)
  806. {
  807.     text = malloc(START_STRSIZE);
  808.     text_asize = START_STRSIZE;
  809.     text_size = 0;
  810.     *text = 0;
  811. }
  812.  
  813. void append_string(const char *str, int size)
  814. {
  815.     int new_size = text_size + size + 1;
  816.     if (new_size > text_asize) {
  817.         new_size += START_STRSIZE - 1;
  818.         new_size &= -START_STRSIZE;
  819.         text = realloc(text, new_size);
  820.         text_asize = new_size;
  821.     }
  822.     memcpy(text + text_size, str, size);
  823.     text_size += size;
  824.     text[text_size] = 0;
  825. }
  826.  
  827. void alloc_string(const char *str, int size)
  828. {
  829.     text = malloc(size + 1);
  830.     memcpy(text, str, size);
  831.     text[size] = 0;
  832. }
  833.  
  834. #define INITIAL 0
  835. #define COMMAND 1
  836. #define HELP 2
  837. #define STRING 3
  838. #define PARAM 4
  839.  
  840. #ifndef YY_NO_UNISTD_H
  841. /* Special case for "unistd.h", since it is non-ANSI. We include it way
  842.  * down here because we want the user's section 1 to have been scanned first.
  843.  * The user has a chance to override it with an option.
  844.  */
  845. #include <unistd.h>
  846. #endif
  847.  
  848. #ifndef YY_EXTRA_TYPE
  849. #define YY_EXTRA_TYPE void *
  850. #endif
  851.  
  852. static int yy_init_globals (void );
  853.  
  854. /* Accessor methods to globals.
  855.    These are made visible to non-reentrant scanners for convenience. */
  856.  
  857. int zconflex_destroy (void );
  858.  
  859. int zconfget_debug (void );
  860.  
  861. void zconfset_debug (int debug_flag  );
  862.  
  863. YY_EXTRA_TYPE zconfget_extra (void );
  864.  
  865. void zconfset_extra (YY_EXTRA_TYPE user_defined  );
  866.  
  867. FILE *zconfget_in (void );
  868.  
  869. void zconfset_in  (FILE * in_str  );
  870.  
  871. FILE *zconfget_out (void );
  872.  
  873. void zconfset_out  (FILE * out_str  );
  874.  
  875. int zconfget_leng (void );
  876.  
  877. char *zconfget_text (void );
  878.  
  879. int zconfget_lineno (void );
  880.  
  881. void zconfset_lineno (int line_number  );
  882.  
  883. /* Macros after this point can all be overridden by user definitions in
  884.  * section 1.
  885.  */
  886.  
  887. #ifndef YY_SKIP_YYWRAP
  888. #ifdef __cplusplus
  889. extern "C" int zconfwrap (void );
  890. #else
  891. extern int zconfwrap (void );
  892. #endif
  893. #endif
  894.  
  895.     static void yyunput (int c,char *buf_ptr  );
  896.     
  897. #ifndef yytext_ptr
  898. static void yy_flex_strncpy (char *,yyconst char *,int );
  899. #endif
  900.  
  901. #ifdef YY_NEED_STRLEN
  902. static int yy_flex_strlen (yyconst char * );
  903. #endif
  904.  
  905. #ifndef YY_NO_INPUT
  906.  
  907. #ifdef __cplusplus
  908. static int yyinput (void );
  909. #else
  910. static int input (void );
  911. #endif
  912.  
  913. #endif
  914.  
  915. /* Amount of stuff to slurp up with each read. */
  916. #ifndef YY_READ_BUF_SIZE
  917. #define YY_READ_BUF_SIZE 8192
  918. #endif
  919.  
  920. /* Copy whatever the last rule matched to the standard output. */
  921. #ifndef ECHO
  922. /* This used to be an fputs(), but since the string might contain NUL's,
  923.  * we now use fwrite().
  924.  */
  925. #define ECHO fwrite( zconftext, zconfleng, 1, zconfout )
  926. #endif
  927.  
  928. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  929.  * is returned in "result".
  930.  */
  931. #ifndef YY_INPUT
  932. #define YY_INPUT(buf,result,max_size) \
  933.     errno=0; \
  934.     while ( (result = read( fileno(zconfin), (char *) buf, max_size )) < 0 ) \
  935.     { \
  936.         if( errno != EINTR) \
  937.         { \
  938.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  939.             break; \
  940.         } \
  941.         errno=0; \
  942.         clearerr(zconfin); \
  943.     }\
  944. \
  945.  
  946. #endif
  947.  
  948. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  949.  * we don't want an extra ';' after the "return" because that will cause
  950.  * some compilers to complain about unreachable statements.
  951.  */
  952. #ifndef yyterminate
  953. #define yyterminate() return YY_NULL
  954. #endif
  955.  
  956. /* Number of entries by which start-condition stack grows. */
  957. #ifndef YY_START_STACK_INCR
  958. #define YY_START_STACK_INCR 25
  959. #endif
  960.  
  961. /* Report a fatal error. */
  962. #ifndef YY_FATAL_ERROR
  963. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  964. #endif
  965.  
  966. /* end tables serialization structures and prototypes */
  967.  
  968. /* Default declaration of generated scanner - a define so the user can
  969.  * easily add parameters.
  970.  */
  971. #ifndef YY_DECL
  972. #define YY_DECL_IS_OURS 1
  973.  
  974. extern int zconflex (void);
  975.  
  976. #define YY_DECL int zconflex (void)
  977. #endif /* !YY_DECL */
  978.  
  979. /* Code executed at the beginning of each rule, after zconftext and zconfleng
  980.  * have been set up.
  981.  */
  982. #ifndef YY_USER_ACTION
  983. #define YY_USER_ACTION
  984. #endif
  985.  
  986. /* Code executed at the end of each rule. */
  987. #ifndef YY_BREAK
  988. #define YY_BREAK break;
  989. #endif
  990.  
  991. #define YY_RULE_SETUP \
  992.     YY_USER_ACTION
  993.  
  994. /** The main scanner function which does all the work.
  995.  */
  996. YY_DECL
  997. {
  998.     register yy_state_type yy_current_state;
  999.     register char *yy_cp, *yy_bp;
  1000.     register int yy_act;
  1001.     
  1002.     int str = 0;
  1003.     int ts, i;
  1004.  
  1005.     if ( !(yy_init) )
  1006.         {
  1007.         (yy_init) = 1;
  1008.  
  1009. #ifdef YY_USER_INIT
  1010.         YY_USER_INIT;
  1011. #endif
  1012.  
  1013.         if ( ! (yy_start) )
  1014.             (yy_start) = 1;    /* first start state */
  1015.  
  1016.         if ( ! zconfin )
  1017.             zconfin = stdin;
  1018.  
  1019.         if ( ! zconfout )
  1020.             zconfout = stdout;
  1021.  
  1022.         if ( ! YY_CURRENT_BUFFER ) {
  1023.             zconfensure_buffer_stack ();
  1024.             YY_CURRENT_BUFFER_LVALUE =
  1025.                 zconf_create_buffer(zconfin,YY_BUF_SIZE );
  1026.         }
  1027.  
  1028.         zconf_load_buffer_state( );
  1029.         }
  1030.  
  1031.     while ( 1 )        /* loops until end-of-file is reached */
  1032.         {
  1033.         yy_cp = (yy_c_buf_p);
  1034.  
  1035.         /* Support of zconftext. */
  1036.         *yy_cp = (yy_hold_char);
  1037.  
  1038.         /* yy_bp points to the position in yy_ch_buf of the start of
  1039.          * the current run.
  1040.          */
  1041.         yy_bp = yy_cp;
  1042.  
  1043.         yy_current_state = (yy_start);
  1044. yy_match:
  1045.         while ( (yy_current_state = yy_nxt[yy_current_state][ yy_ec[YY_SC_TO_UI(*yy_cp)]  ]) > 0 )
  1046.             ++yy_cp;
  1047.  
  1048.         yy_current_state = -yy_current_state;
  1049.  
  1050. yy_find_action:
  1051.         yy_act = yy_accept[yy_current_state];
  1052.  
  1053.         YY_DO_BEFORE_ACTION;
  1054.  
  1055. do_action:    /* This label is used only to access EOF actions. */
  1056.  
  1057.         switch ( yy_act )
  1058.     { /* beginning of action switch */
  1059. case 1:
  1060. /* rule 1 can match eol */
  1061. case 2:
  1062. /* rule 2 can match eol */
  1063. YY_RULE_SETUP
  1064. {
  1065.     current_file->lineno++;
  1066.     return T_EOL;
  1067. }
  1068.     YY_BREAK
  1069. case 3:
  1070. YY_RULE_SETUP
  1071.  
  1072.     YY_BREAK
  1073. case 4:
  1074. YY_RULE_SETUP
  1075. {
  1076.     BEGIN(COMMAND);
  1077. }
  1078.     YY_BREAK
  1079. case 5:
  1080. YY_RULE_SETUP
  1081. {
  1082.     unput(zconftext[0]);
  1083.     BEGIN(COMMAND);
  1084. }
  1085.     YY_BREAK
  1086.  
  1087. case 6:
  1088. YY_RULE_SETUP
  1089. {
  1090.         struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
  1091.         BEGIN(PARAM);
  1092.         current_pos.file = current_file;
  1093.         current_pos.lineno = current_file->lineno;
  1094.         if (id && id->flags & TF_COMMAND) {
  1095.             zconflval.id = id;
  1096.             return id->token;
  1097.         }
  1098.         alloc_string(zconftext, zconfleng);
  1099.         zconflval.string = text;
  1100.         return T_WORD;
  1101.     }
  1102.     YY_BREAK
  1103. case 7:
  1104. YY_RULE_SETUP
  1105.  
  1106.     YY_BREAK
  1107. case 8:
  1108. /* rule 8 can match eol */
  1109. YY_RULE_SETUP
  1110. {
  1111.         BEGIN(INITIAL);
  1112.         current_file->lineno++;
  1113.         return T_EOL;
  1114.     }
  1115.     YY_BREAK
  1116.  
  1117. case 9:
  1118. YY_RULE_SETUP
  1119. return T_AND;
  1120.     YY_BREAK
  1121. case 10:
  1122. YY_RULE_SETUP
  1123. return T_OR;
  1124.     YY_BREAK
  1125. case 11:
  1126. YY_RULE_SETUP
  1127. return T_OPEN_PAREN;
  1128.     YY_BREAK
  1129. case 12:
  1130. YY_RULE_SETUP
  1131. return T_CLOSE_PAREN;
  1132.     YY_BREAK
  1133. case 13:
  1134. YY_RULE_SETUP
  1135. return T_NOT;
  1136.     YY_BREAK
  1137. case 14:
  1138. YY_RULE_SETUP
  1139. return T_EQUAL;
  1140.     YY_BREAK
  1141. case 15:
  1142. YY_RULE_SETUP
  1143. return T_UNEQUAL;
  1144.     YY_BREAK
  1145. case 16:
  1146. YY_RULE_SETUP
  1147. {
  1148.         str = zconftext[0];
  1149.         new_string();
  1150.         BEGIN(STRING);
  1151.     }
  1152.     YY_BREAK
  1153. case 17:
  1154. /* rule 17 can match eol */
  1155. YY_RULE_SETUP
  1156. BEGIN(INITIAL); current_file->lineno++; return T_EOL;
  1157.     YY_BREAK
  1158. case 18:
  1159. YY_RULE_SETUP
  1160. /* ignore */
  1161.     YY_BREAK
  1162. case 19:
  1163. YY_RULE_SETUP
  1164. {
  1165.         struct kconf_id *id = kconf_id_lookup(zconftext, zconfleng);
  1166.         if (id && id->flags & TF_PARAM) {
  1167.             zconflval.id = id;
  1168.             return id->token;
  1169.         }
  1170.         alloc_string(zconftext, zconfleng);
  1171.         zconflval.string = text;
  1172.         return T_WORD;
  1173.     }
  1174.     YY_BREAK
  1175. case 20:
  1176. YY_RULE_SETUP
  1177. /* comment */
  1178.     YY_BREAK
  1179. case 21:
  1180. /* rule 21 can match eol */
  1181. YY_RULE_SETUP
  1182. current_file->lineno++;
  1183.     YY_BREAK
  1184. case 22:
  1185. YY_RULE_SETUP
  1186.  
  1187.     YY_BREAK
  1188. case YY_STATE_EOF(PARAM):
  1189. {
  1190.         BEGIN(INITIAL);
  1191.     }
  1192.     YY_BREAK
  1193.  
  1194. case 23:
  1195. /* rule 23 can match eol */
  1196. *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
  1197. (yy_c_buf_p) = yy_cp -= 1;
  1198. YY_DO_BEFORE_ACTION; /* set up zconftext again */
  1199. YY_RULE_SETUP
  1200. {
  1201.         append_string(zconftext, zconfleng);
  1202.         zconflval.string = text;
  1203.         return T_WORD_QUOTE;
  1204.     }
  1205.     YY_BREAK
  1206. case 24:
  1207. YY_RULE_SETUP
  1208. {
  1209.         append_string(zconftext, zconfleng);
  1210.     }
  1211.     YY_BREAK
  1212. case 25:
  1213. /* rule 25 can match eol */
  1214. *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
  1215. (yy_c_buf_p) = yy_cp -= 1;
  1216. YY_DO_BEFORE_ACTION; /* set up zconftext again */
  1217. YY_RULE_SETUP
  1218. {
  1219.         append_string(zconftext + 1, zconfleng - 1);
  1220.         zconflval.string = text;
  1221.         return T_WORD_QUOTE;
  1222.     }
  1223.     YY_BREAK
  1224. case 26:
  1225. YY_RULE_SETUP
  1226. {
  1227.         append_string(zconftext + 1, zconfleng - 1);
  1228.     }
  1229.     YY_BREAK
  1230. case 27:
  1231. YY_RULE_SETUP
  1232. {
  1233.         if (str == zconftext[0]) {
  1234.             BEGIN(PARAM);
  1235.             zconflval.string = text;
  1236.             return T_WORD_QUOTE;
  1237.         } else
  1238.             append_string(zconftext, 1);
  1239.     }
  1240.     YY_BREAK
  1241. case 28:
  1242. /* rule 28 can match eol */
  1243. YY_RULE_SETUP
  1244. {
  1245.         printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
  1246.         current_file->lineno++;
  1247.         BEGIN(INITIAL);
  1248.         return T_EOL;
  1249.     }
  1250.     YY_BREAK
  1251. case YY_STATE_EOF(STRING):
  1252. {
  1253.         BEGIN(INITIAL);
  1254.     }
  1255.     YY_BREAK
  1256.  
  1257. case 29:
  1258. YY_RULE_SETUP
  1259. {
  1260.         ts = 0;
  1261.         for (i = 0; i < zconfleng; i++) {
  1262.             if (zconftext[i] == '\t')
  1263.                 ts = (ts & ~7) + 8;
  1264.             else
  1265.                 ts++;
  1266.         }
  1267.         last_ts = ts;
  1268.         if (first_ts) {
  1269.             if (ts < first_ts) {
  1270.                 zconf_endhelp();
  1271.                 return T_HELPTEXT;
  1272.             }
  1273.             ts -= first_ts;
  1274.             while (ts > 8) {
  1275.                 append_string("        ", 8);
  1276.                 ts -= 8;
  1277.             }
  1278.             append_string("        ", ts);
  1279.         }
  1280.     }
  1281.     YY_BREAK
  1282. case 30:
  1283. /* rule 30 can match eol */
  1284. *yy_cp = (yy_hold_char); /* undo effects of setting up zconftext */
  1285. (yy_c_buf_p) = yy_cp -= 1;
  1286. YY_DO_BEFORE_ACTION; /* set up zconftext again */
  1287. YY_RULE_SETUP
  1288. {
  1289.         current_file->lineno++;
  1290.         zconf_endhelp();
  1291.         return T_HELPTEXT;
  1292.     }
  1293.     YY_BREAK
  1294. case 31:
  1295. /* rule 31 can match eol */
  1296. YY_RULE_SETUP
  1297. {
  1298.         current_file->lineno++;
  1299.         append_string("\n", 1);
  1300.     }
  1301.     YY_BREAK
  1302. case 32:
  1303. YY_RULE_SETUP
  1304. {
  1305.         while (zconfleng) {
  1306.             if ((zconftext[zconfleng-1] != ' ') && (zconftext[zconfleng-1] != '\t'))
  1307.                 break;
  1308.             zconfleng--;
  1309.         }
  1310.         append_string(zconftext, zconfleng);
  1311.         if (!first_ts)
  1312.             first_ts = last_ts;
  1313.     }
  1314.     YY_BREAK
  1315. case YY_STATE_EOF(HELP):
  1316. {
  1317.         zconf_endhelp();
  1318.         return T_HELPTEXT;
  1319.     }
  1320.     YY_BREAK
  1321.  
  1322. case YY_STATE_EOF(INITIAL):
  1323. case YY_STATE_EOF(COMMAND):
  1324. {
  1325.     if (current_file) {
  1326.         zconf_endfile();
  1327.         return T_EOL;
  1328.     }
  1329.     fclose(zconfin);
  1330.     yyterminate();
  1331. }
  1332.     YY_BREAK
  1333. case 33:
  1334. YY_RULE_SETUP
  1335. YY_FATAL_ERROR( "flex scanner jammed" );
  1336.     YY_BREAK
  1337.  
  1338.     case YY_END_OF_BUFFER:
  1339.         {
  1340.         /* Amount of text matched not including the EOB char. */
  1341.         int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
  1342.  
  1343.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1344.         *yy_cp = (yy_hold_char);
  1345.         YY_RESTORE_YY_MORE_OFFSET
  1346.  
  1347.         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
  1348.             {
  1349.             /* We're scanning a new file or input source.  It's
  1350.              * possible that this happened because the user
  1351.              * just pointed zconfin at a new source and called
  1352.              * zconflex().  If so, then we have to assure
  1353.              * consistency between YY_CURRENT_BUFFER and our
  1354.              * globals.  Here is the right place to do so, because
  1355.              * this is the first action (other than possibly a
  1356.              * back-up) that will match for the new input source.
  1357.              */
  1358.             (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
  1359.             YY_CURRENT_BUFFER_LVALUE->yy_input_file = zconfin;
  1360.             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
  1361.             }
  1362.  
  1363.         /* Note that here we test for yy_c_buf_p "<=" to the position
  1364.          * of the first EOB in the buffer, since yy_c_buf_p will
  1365.          * already have been incremented past the NUL character
  1366.          * (since all states make transitions on EOB to the
  1367.          * end-of-buffer state).  Contrast this with the test
  1368.          * in input().
  1369.          */
  1370.         if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
  1371.             { /* This was really a NUL. */
  1372.             yy_state_type yy_next_state;
  1373.  
  1374.             (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
  1375.  
  1376.             yy_current_state = yy_get_previous_state(  );
  1377.  
  1378.             /* Okay, we're now positioned to make the NUL
  1379.              * transition.  We couldn't have
  1380.              * yy_get_previous_state() go ahead and do it
  1381.              * for us because it doesn't know how to deal
  1382.              * with the possibility of jamming (and we don't
  1383.              * want to build jamming into it because then it
  1384.              * will run more slowly).
  1385.              */
  1386.  
  1387.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  1388.  
  1389.             yy_bp = (yytext_ptr) + YY_MORE_ADJ;
  1390.  
  1391.             if ( yy_next_state )
  1392.                 {
  1393.                 /* Consume the NUL. */
  1394.                 yy_cp = ++(yy_c_buf_p);
  1395.                 yy_current_state = yy_next_state;
  1396.                 goto yy_match;
  1397.                 }
  1398.  
  1399.             else
  1400.                 {
  1401.                 yy_cp = (yy_c_buf_p);
  1402.                 goto yy_find_action;
  1403.                 }
  1404.             }
  1405.  
  1406.         else switch ( yy_get_next_buffer(  ) )
  1407.             {
  1408.             case EOB_ACT_END_OF_FILE:
  1409.                 {
  1410.                 (yy_did_buffer_switch_on_eof) = 0;
  1411.  
  1412.                 if ( zconfwrap( ) )
  1413.                     {
  1414.                     /* Note: because we've taken care in
  1415.                      * yy_get_next_buffer() to have set up
  1416.                      * zconftext, we can now set up
  1417.                      * yy_c_buf_p so that if some total
  1418.                      * hoser (like flex itself) wants to
  1419.                      * call the scanner after we return the
  1420.                      * YY_NULL, it'll still work - another
  1421.                      * YY_NULL will get returned.
  1422.                      */
  1423.                     (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
  1424.  
  1425.                     yy_act = YY_STATE_EOF(YY_START);
  1426.                     goto do_action;
  1427.                     }
  1428.  
  1429.                 else
  1430.                     {
  1431.                     if ( ! (yy_did_buffer_switch_on_eof) )
  1432.                         YY_NEW_FILE;
  1433.                     }
  1434.                 break;
  1435.                 }
  1436.  
  1437.             case EOB_ACT_CONTINUE_SCAN:
  1438.                 (yy_c_buf_p) =
  1439.                     (yytext_ptr) + yy_amount_of_matched_text;
  1440.  
  1441.                 yy_current_state = yy_get_previous_state(  );
  1442.  
  1443.                 yy_cp = (yy_c_buf_p);
  1444.                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
  1445.                 goto yy_match;
  1446.  
  1447.             case EOB_ACT_LAST_MATCH:
  1448.                 (yy_c_buf_p) =
  1449.                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
  1450.  
  1451.                 yy_current_state = yy_get_previous_state(  );
  1452.  
  1453.                 yy_cp = (yy_c_buf_p);
  1454.                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
  1455.                 goto yy_find_action;
  1456.             }
  1457.         break;
  1458.         }
  1459.  
  1460.     default:
  1461.         YY_FATAL_ERROR(
  1462.             "fatal flex scanner internal error--no action found" );
  1463.     } /* end of action switch */
  1464.         } /* end of scanning one token */
  1465. } /* end of zconflex */
  1466.  
  1467. /* yy_get_next_buffer - try to read in a new buffer
  1468.  *
  1469.  * Returns a code representing an action:
  1470.  *    EOB_ACT_LAST_MATCH -
  1471.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1472.  *    EOB_ACT_END_OF_FILE - end of file
  1473.  */
  1474. static int yy_get_next_buffer (void)
  1475. {
  1476.         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
  1477.     register char *source = (yytext_ptr);
  1478.     register int number_to_move, i;
  1479.     int ret_val;
  1480.  
  1481.     if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
  1482.         YY_FATAL_ERROR(
  1483.         "fatal flex scanner internal error--end of buffer missed" );
  1484.  
  1485.     if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
  1486.         { /* Don't try to fill the buffer, so this is an EOF. */
  1487.         if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
  1488.             {
  1489.             /* We matched a single character, the EOB, so
  1490.              * treat this as a final EOF.
  1491.              */
  1492.             return EOB_ACT_END_OF_FILE;
  1493.             }
  1494.  
  1495.         else
  1496.             {
  1497.             /* We matched some text prior to the EOB, first
  1498.              * process it.
  1499.              */
  1500.             return EOB_ACT_LAST_MATCH;
  1501.             }
  1502.         }
  1503.  
  1504.     /* Try to read more data. */
  1505.  
  1506.     /* First move last chars to start of buffer. */
  1507.     number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
  1508.  
  1509.     for ( i = 0; i < number_to_move; ++i )
  1510.         *(dest++) = *(source++);
  1511.  
  1512.     if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1513.         /* don't do the read, it's not guaranteed to return an EOF,
  1514.          * just force an EOF
  1515.          */
  1516.         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
  1517.  
  1518.     else
  1519.         {
  1520.             int num_to_read =
  1521.             YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
  1522.  
  1523.         while ( num_to_read <= 0 )
  1524.             { /* Not enough room in the buffer - grow it. */
  1525.  
  1526.             /* just a shorter name for the current buffer */
  1527.             YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
  1528.  
  1529.             int yy_c_buf_p_offset =
  1530.                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
  1531.  
  1532.             if ( b->yy_is_our_buffer )
  1533.                 {
  1534.                 int new_size = b->yy_buf_size * 2;
  1535.  
  1536.                 if ( new_size <= 0 )
  1537.                     b->yy_buf_size += b->yy_buf_size / 8;
  1538.                 else
  1539.                     b->yy_buf_size *= 2;
  1540.  
  1541.                 b->yy_ch_buf = (char *)
  1542.                     /* Include room in for 2 EOB chars. */
  1543.                     zconfrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
  1544.                 }
  1545.             else
  1546.                 /* Can't grow it, we don't own it. */
  1547.                 b->yy_ch_buf = 0;
  1548.  
  1549.             if ( ! b->yy_ch_buf )
  1550.                 YY_FATAL_ERROR(
  1551.                 "fatal error - scanner input buffer overflow" );
  1552.  
  1553.             (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
  1554.  
  1555.             num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
  1556.                         number_to_move - 1;
  1557.  
  1558.             }
  1559.  
  1560.         if ( num_to_read > YY_READ_BUF_SIZE )
  1561.             num_to_read = YY_READ_BUF_SIZE;
  1562.  
  1563.         /* Read in more data. */
  1564.         YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
  1565.             (yy_n_chars), (size_t) num_to_read );
  1566.  
  1567.         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
  1568.         }
  1569.  
  1570.     if ( (yy_n_chars) == 0 )
  1571.         {
  1572.         if ( number_to_move == YY_MORE_ADJ )
  1573.             {
  1574.             ret_val = EOB_ACT_END_OF_FILE;
  1575.             zconfrestart(zconfin  );
  1576.             }
  1577.  
  1578.         else
  1579.             {
  1580.             ret_val = EOB_ACT_LAST_MATCH;
  1581.             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
  1582.                 YY_BUFFER_EOF_PENDING;
  1583.             }
  1584.         }
  1585.  
  1586.     else
  1587.         ret_val = EOB_ACT_CONTINUE_SCAN;
  1588.  
  1589.     if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
  1590.         /* Extend the array by 50%, plus the number we really need. */
  1591.         yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
  1592.         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) zconfrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
  1593.         if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
  1594.             YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
  1595.     }
  1596.  
  1597.     (yy_n_chars) += number_to_move;
  1598.     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
  1599.     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
  1600.  
  1601.     (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
  1602.  
  1603.     return ret_val;
  1604. }
  1605.  
  1606. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1607.  
  1608.     static yy_state_type yy_get_previous_state (void)
  1609. {
  1610.     register yy_state_type yy_current_state;
  1611.     register char *yy_cp;
  1612.     
  1613.     yy_current_state = (yy_start);
  1614.  
  1615.     for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
  1616.         {
  1617.         yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
  1618.         }
  1619.  
  1620.     return yy_current_state;
  1621. }
  1622.  
  1623. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1624.  *
  1625.  * synopsis
  1626.  *    next_state = yy_try_NUL_trans( current_state );
  1627.  */
  1628.     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
  1629. {
  1630.     register int yy_is_jam;
  1631.     
  1632.     yy_current_state = yy_nxt[yy_current_state][1];
  1633.     yy_is_jam = (yy_current_state <= 0);
  1634.  
  1635.     return yy_is_jam ? 0 : yy_current_state;
  1636. }
  1637.  
  1638.     static void yyunput (int c, register char * yy_bp )
  1639. {
  1640.     register char *yy_cp;
  1641.     
  1642.     yy_cp = (yy_c_buf_p);
  1643.  
  1644.     /* undo effects of setting up zconftext */
  1645.     *yy_cp = (yy_hold_char);
  1646.  
  1647.     if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
  1648.         { /* need to shift things up to make room */
  1649.         /* +2 for EOB chars. */
  1650.         register int number_to_move = (yy_n_chars) + 2;
  1651.         register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
  1652.                     YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
  1653.         register char *source =
  1654.                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
  1655.  
  1656.         while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
  1657.             *--dest = *--source;
  1658.  
  1659.         yy_cp += (int) (dest - source);
  1660.         yy_bp += (int) (dest - source);
  1661.         YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
  1662.             (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
  1663.  
  1664.         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
  1665.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1666.         }
  1667.  
  1668.     *--yy_cp = (char) c;
  1669.  
  1670.     (yytext_ptr) = yy_bp;
  1671.     (yy_hold_char) = *yy_cp;
  1672.     (yy_c_buf_p) = yy_cp;
  1673. }
  1674.  
  1675. #ifndef YY_NO_INPUT
  1676. #ifdef __cplusplus
  1677.     static int yyinput (void)
  1678. #else
  1679.     static int input  (void)
  1680. #endif
  1681.  
  1682. {
  1683.     int c;
  1684.     
  1685.     *(yy_c_buf_p) = (yy_hold_char);
  1686.  
  1687.     if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
  1688.         {
  1689.         /* yy_c_buf_p now points to the character we want to return.
  1690.          * If this occurs *before* the EOB characters, then it's a
  1691.          * valid NUL; if not, then we've hit the end of the buffer.
  1692.          */
  1693.         if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
  1694.             /* This was really a NUL. */
  1695.             *(yy_c_buf_p) = '\0';
  1696.  
  1697.         else
  1698.             { /* need more input */
  1699.             int offset = (yy_c_buf_p) - (yytext_ptr);
  1700.             ++(yy_c_buf_p);
  1701.  
  1702.             switch ( yy_get_next_buffer(  ) )
  1703.                 {
  1704.                 case EOB_ACT_LAST_MATCH:
  1705.                     /* This happens because yy_g_n_b()
  1706.                      * sees that we've accumulated a
  1707.                      * token and flags that we need to
  1708.                      * try matching the token before
  1709.                      * proceeding.  But for input(),
  1710.                      * there's no matching to consider.
  1711.                      * So convert the EOB_ACT_LAST_MATCH
  1712.                      * to EOB_ACT_END_OF_FILE.
  1713.                      */
  1714.  
  1715.                     /* Reset buffer status. */
  1716.                     zconfrestart(zconfin );
  1717.  
  1718.                     /*FALLTHROUGH*/
  1719.  
  1720.                 case EOB_ACT_END_OF_FILE:
  1721.                     {
  1722.                     if ( zconfwrap( ) )
  1723.                         return EOF;
  1724.  
  1725.                     if ( ! (yy_did_buffer_switch_on_eof) )
  1726.                         YY_NEW_FILE;
  1727. #ifdef __cplusplus
  1728.                     return yyinput();
  1729. #else
  1730.                     return input();
  1731. #endif
  1732.                     }
  1733.  
  1734.                 case EOB_ACT_CONTINUE_SCAN:
  1735.                     (yy_c_buf_p) = (yytext_ptr) + offset;
  1736.                     break;
  1737.                 }
  1738.             }
  1739.         }
  1740.  
  1741.     c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
  1742.     *(yy_c_buf_p) = '\0';    /* preserve zconftext */
  1743.     (yy_hold_char) = *++(yy_c_buf_p);
  1744.  
  1745.     return c;
  1746. }
  1747. #endif    /* ifndef YY_NO_INPUT */
  1748.  
  1749. /** Immediately switch to a different input stream.
  1750.  * @param input_file A readable stream.
  1751.  * 
  1752.  * @note This function does not reset the start condition to @c INITIAL .
  1753.  */
  1754.     void zconfrestart  (FILE * input_file )
  1755. {
  1756.     
  1757.     if ( ! YY_CURRENT_BUFFER ){
  1758.         zconfensure_buffer_stack ();
  1759.         YY_CURRENT_BUFFER_LVALUE =
  1760.             zconf_create_buffer(zconfin,YY_BUF_SIZE );
  1761.     }
  1762.  
  1763.     zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
  1764.     zconf_load_buffer_state( );
  1765. }
  1766.  
  1767. /** Switch to a different input buffer.
  1768.  * @param new_buffer The new input buffer.
  1769.  * 
  1770.  */
  1771.     void zconf_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
  1772. {
  1773.     
  1774.     /* TODO. We should be able to replace this entire function body
  1775.      * with
  1776.      *        zconfpop_buffer_state();
  1777.      *        zconfpush_buffer_state(new_buffer);
  1778.      */
  1779.     zconfensure_buffer_stack ();
  1780.     if ( YY_CURRENT_BUFFER == new_buffer )
  1781.         return;
  1782.  
  1783.     if ( YY_CURRENT_BUFFER )
  1784.         {
  1785.         /* Flush out information for old buffer. */
  1786.         *(yy_c_buf_p) = (yy_hold_char);
  1787.         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
  1788.         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
  1789.         }
  1790.  
  1791.     YY_CURRENT_BUFFER_LVALUE = new_buffer;
  1792.     zconf_load_buffer_state( );
  1793.  
  1794.     /* We don't actually know whether we did this switch during
  1795.      * EOF (zconfwrap()) processing, but the only time this flag
  1796.      * is looked at is after zconfwrap() is called, so it's safe
  1797.      * to go ahead and always set it.
  1798.      */
  1799.     (yy_did_buffer_switch_on_eof) = 1;
  1800. }
  1801.  
  1802. static void zconf_load_buffer_state  (void)
  1803. {
  1804.         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
  1805.     (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
  1806.     zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
  1807.     (yy_hold_char) = *(yy_c_buf_p);
  1808. }
  1809.  
  1810. /** Allocate and initialize an input buffer state.
  1811.  * @param file A readable stream.
  1812.  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
  1813.  * 
  1814.  * @return the allocated buffer state.
  1815.  */
  1816.     YY_BUFFER_STATE zconf_create_buffer  (FILE * file, int  size )
  1817. {
  1818.     YY_BUFFER_STATE b;
  1819.     
  1820.     b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
  1821.     if ( ! b )
  1822.         YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
  1823.  
  1824.     b->yy_buf_size = size;
  1825.  
  1826.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1827.      * we need to put in 2 end-of-buffer characters.
  1828.      */
  1829.     b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2  );
  1830.     if ( ! b->yy_ch_buf )
  1831.         YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );
  1832.  
  1833.     b->yy_is_our_buffer = 1;
  1834.  
  1835.     zconf_init_buffer(b,file );
  1836.  
  1837.     return b;
  1838. }
  1839.  
  1840. /** Destroy the buffer.
  1841.  * @param b a buffer created with zconf_create_buffer()
  1842.  * 
  1843.  */
  1844.     void zconf_delete_buffer (YY_BUFFER_STATE  b )
  1845. {
  1846.     
  1847.     if ( ! b )
  1848.         return;
  1849.  
  1850.     if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
  1851.         YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
  1852.  
  1853.     if ( b->yy_is_our_buffer )
  1854.         zconffree((void *) b->yy_ch_buf  );
  1855.  
  1856.     zconffree((void *) b  );
  1857. }
  1858.  
  1859. /* Initializes or reinitializes a buffer.
  1860.  * This function is sometimes called more than once on the same buffer,
  1861.  * such as during a zconfrestart() or at EOF.
  1862.  */
  1863.     static void zconf_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
  1864.  
  1865. {
  1866.     int oerrno = errno;
  1867.     
  1868.     zconf_flush_buffer(b );
  1869.  
  1870.     b->yy_input_file = file;
  1871.     b->yy_fill_buffer = 1;
  1872.  
  1873.     /* If b is the current buffer, then zconf_init_buffer was _probably_
  1874.      * called from zconfrestart() or through yy_get_next_buffer.
  1875.      * In that case, we don't want to reset the lineno or column.
  1876.      */
  1877.     if (b != YY_CURRENT_BUFFER){
  1878.         b->yy_bs_lineno = 1;
  1879.         b->yy_bs_column = 0;
  1880.     }
  1881.  
  1882.         b->yy_is_interactive = 0;
  1883.     
  1884.     errno = oerrno;
  1885. }
  1886.  
  1887. /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
  1888.  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
  1889.  * 
  1890.  */
  1891.     void zconf_flush_buffer (YY_BUFFER_STATE  b )
  1892. {
  1893.         if ( ! b )
  1894.         return;
  1895.  
  1896.     b->yy_n_chars = 0;
  1897.  
  1898.     /* We always need two end-of-buffer characters.  The first causes
  1899.      * a transition to the end-of-buffer state.  The second causes
  1900.      * a jam in that state.
  1901.      */
  1902.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1903.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1904.  
  1905.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1906.  
  1907.     b->yy_at_bol = 1;
  1908.     b->yy_buffer_status = YY_BUFFER_NEW;
  1909.  
  1910.     if ( b == YY_CURRENT_BUFFER )
  1911.         zconf_load_buffer_state( );
  1912. }
  1913.  
  1914. /** Pushes the new state onto the stack. The new state becomes
  1915.  *  the current state. This function will allocate the stack
  1916.  *  if necessary.
  1917.  *  @param new_buffer The new state.
  1918.  *  
  1919.  */
  1920. void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
  1921. {
  1922.         if (new_buffer == NULL)
  1923.         return;
  1924.  
  1925.     zconfensure_buffer_stack();
  1926.  
  1927.     /* This block is copied from zconf_switch_to_buffer. */
  1928.     if ( YY_CURRENT_BUFFER )
  1929.         {
  1930.         /* Flush out information for old buffer. */
  1931.         *(yy_c_buf_p) = (yy_hold_char);
  1932.         YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
  1933.         YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
  1934.         }
  1935.  
  1936.     /* Only push if top exists. Otherwise, replace top. */
  1937.     if (YY_CURRENT_BUFFER)
  1938.         (yy_buffer_stack_top)++;
  1939.     YY_CURRENT_BUFFER_LVALUE = new_buffer;
  1940.  
  1941.     /* copied from zconf_switch_to_buffer. */
  1942.     zconf_load_buffer_state( );
  1943.     (yy_did_buffer_switch_on_eof) = 1;
  1944. }
  1945.  
  1946. /** Removes and deletes the top of the stack, if present.
  1947.  *  The next element becomes the new top.
  1948.  *  
  1949.  */
  1950. void zconfpop_buffer_state (void)
  1951. {
  1952.         if (!YY_CURRENT_BUFFER)
  1953.         return;
  1954.  
  1955.     zconf_delete_buffer(YY_CURRENT_BUFFER );
  1956.     YY_CURRENT_BUFFER_LVALUE = NULL;
  1957.     if ((yy_buffer_stack_top) > 0)
  1958.         --(yy_buffer_stack_top);
  1959.  
  1960.     if (YY_CURRENT_BUFFER) {
  1961.         zconf_load_buffer_state( );
  1962.         (yy_did_buffer_switch_on_eof) = 1;
  1963.     }
  1964. }
  1965.  
  1966. /* Allocates the stack if it does not exist.
  1967.  *  Guarantees space for at least one push.
  1968.  */
  1969. static void zconfensure_buffer_stack (void)
  1970. {
  1971.     int num_to_alloc;
  1972.     
  1973.     if (!(yy_buffer_stack)) {
  1974.  
  1975.         /* First allocation is just for 2 elements, since we don't know if this
  1976.          * scanner will even need a stack. We use 2 instead of 1 to avoid an
  1977.          * immediate realloc on the next call.
  1978.          */
  1979.         num_to_alloc = 1;
  1980.         (yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
  1981.                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
  1982.                                 );
  1983.         if ( ! (yy_buffer_stack) )
  1984.             YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
  1985.                                   
  1986.         memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
  1987.                 
  1988.         (yy_buffer_stack_max) = num_to_alloc;
  1989.         (yy_buffer_stack_top) = 0;
  1990.         return;
  1991.     }
  1992.  
  1993.     if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
  1994.  
  1995.         /* Increase the buffer to prepare for a possible push. */
  1996.         int grow_size = 8 /* arbitrary grow size */;
  1997.  
  1998.         num_to_alloc = (yy_buffer_stack_max) + grow_size;
  1999.         (yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
  2000.                                 ((yy_buffer_stack),
  2001.                                 num_to_alloc * sizeof(struct yy_buffer_state*)
  2002.                                 );
  2003.         if ( ! (yy_buffer_stack) )
  2004.             YY_FATAL_ERROR( "out of dynamic memory in zconfensure_buffer_stack()" );
  2005.  
  2006.         /* zero only the new slots.*/
  2007.         memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
  2008.         (yy_buffer_stack_max) = num_to_alloc;
  2009.     }
  2010. }
  2011.  
  2012. /** Setup the input buffer state to scan directly from a user-specified character buffer.
  2013.  * @param base the character buffer
  2014.  * @param size the size in bytes of the character buffer
  2015.  * 
  2016.  * @return the newly allocated buffer state object. 
  2017.  */
  2018. YY_BUFFER_STATE zconf_scan_buffer  (char * base, yy_size_t  size )
  2019. {
  2020.     YY_BUFFER_STATE b;
  2021.     
  2022.     if ( size < 2 ||
  2023.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  2024.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  2025.         /* They forgot to leave room for the EOB's. */
  2026.         return 0;
  2027.  
  2028.     b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
  2029.     if ( ! b )
  2030.         YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_buffer()" );
  2031.  
  2032.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  2033.     b->yy_buf_pos = b->yy_ch_buf = base;
  2034.     b->yy_is_our_buffer = 0;
  2035.     b->yy_input_file = 0;
  2036.     b->yy_n_chars = b->yy_buf_size;
  2037.     b->yy_is_interactive = 0;
  2038.     b->yy_at_bol = 1;
  2039.     b->yy_fill_buffer = 0;
  2040.     b->yy_buffer_status = YY_BUFFER_NEW;
  2041.  
  2042.     zconf_switch_to_buffer(b  );
  2043.  
  2044.     return b;
  2045. }
  2046.  
  2047. /** Setup the input buffer state to scan a string. The next call to zconflex() will
  2048.  * scan from a @e copy of @a str.
  2049.  * @param yystr a NUL-terminated string to scan
  2050.  * 
  2051.  * @return the newly allocated buffer state object.
  2052.  * @note If you want to scan bytes that may contain NUL values, then use
  2053.  *       zconf_scan_bytes() instead.
  2054.  */
  2055. YY_BUFFER_STATE zconf_scan_string (yyconst char * yystr )
  2056. {
  2057.     
  2058.     return zconf_scan_bytes(yystr,strlen(yystr) );
  2059. }
  2060.  
  2061. /** Setup the input buffer state to scan the given bytes. The next call to zconflex() will
  2062.  * scan from a @e copy of @a bytes.
  2063.  * @param bytes the byte buffer to scan
  2064.  * @param len the number of bytes in the buffer pointed to by @a bytes.
  2065.  * 
  2066.  * @return the newly allocated buffer state object.
  2067.  */
  2068. YY_BUFFER_STATE zconf_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
  2069. {
  2070.     YY_BUFFER_STATE b;
  2071.     char *buf;
  2072.     yy_size_t n;
  2073.     int i;
  2074.     
  2075.     /* Get memory for full buffer, including space for trailing EOB's. */
  2076.     n = _yybytes_len + 2;
  2077.     buf = (char *) zconfalloc(n  );
  2078.     if ( ! buf )
  2079.         YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );
  2080.  
  2081.     for ( i = 0; i < _yybytes_len; ++i )
  2082.         buf[i] = yybytes[i];
  2083.  
  2084.     buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
  2085.  
  2086.     b = zconf_scan_buffer(buf,n );
  2087.     if ( ! b )
  2088.         YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );
  2089.  
  2090.     /* It's okay to grow etc. this buffer, and we should throw it
  2091.      * away when we're done.
  2092.      */
  2093.     b->yy_is_our_buffer = 1;
  2094.  
  2095.     return b;
  2096. }
  2097.  
  2098. #ifndef YY_EXIT_FAILURE
  2099. #define YY_EXIT_FAILURE 2
  2100. #endif
  2101.  
  2102. static void yy_fatal_error (yyconst char* msg )
  2103. {
  2104.         (void) fprintf( stderr, "%s\n", msg );
  2105.     exit( YY_EXIT_FAILURE );
  2106. }
  2107.  
  2108. /* Redefine yyless() so it works in section 3 code. */
  2109.  
  2110. #undef yyless
  2111. #define yyless(n) \
  2112.     do \
  2113.         { \
  2114.         /* Undo effects of setting up zconftext. */ \
  2115.         int yyless_macro_arg = (n); \
  2116.         YY_LESS_LINENO(yyless_macro_arg);\
  2117.         zconftext[zconfleng] = (yy_hold_char); \
  2118.         (yy_c_buf_p) = zconftext + yyless_macro_arg; \
  2119.         (yy_hold_char) = *(yy_c_buf_p); \
  2120.         *(yy_c_buf_p) = '\0'; \
  2121.         zconfleng = yyless_macro_arg; \
  2122.         } \
  2123.     while ( 0 )
  2124.  
  2125. /* Accessor  methods (get/set functions) to struct members. */
  2126.  
  2127. /** Get the current line number.
  2128.  * 
  2129.  */
  2130. int zconfget_lineno  (void)
  2131. {
  2132.         
  2133.     return zconflineno;
  2134. }
  2135.  
  2136. /** Get the input stream.
  2137.  * 
  2138.  */
  2139. FILE *zconfget_in  (void)
  2140. {
  2141.         return zconfin;
  2142. }
  2143.  
  2144. /** Get the output stream.
  2145.  * 
  2146.  */
  2147. FILE *zconfget_out  (void)
  2148. {
  2149.         return zconfout;
  2150. }
  2151.  
  2152. /** Get the length of the current token.
  2153.  * 
  2154.  */
  2155. int zconfget_leng  (void)
  2156. {
  2157.         return zconfleng;
  2158. }
  2159.  
  2160. /** Get the current token.
  2161.  * 
  2162.  */
  2163.  
  2164. char *zconfget_text  (void)
  2165. {
  2166.         return zconftext;
  2167. }
  2168.  
  2169. /** Set the current line number.
  2170.  * @param line_number
  2171.  * 
  2172.  */
  2173. void zconfset_lineno (int  line_number )
  2174. {
  2175.     
  2176.     zconflineno = line_number;
  2177. }
  2178.  
  2179. /** Set the input stream. This does not discard the current
  2180.  * input buffer.
  2181.  * @param in_str A readable stream.
  2182.  * 
  2183.  * @see zconf_switch_to_buffer
  2184.  */
  2185. void zconfset_in (FILE *  in_str )
  2186. {
  2187.         zconfin = in_str ;
  2188. }
  2189.  
  2190. void zconfset_out (FILE *  out_str )
  2191. {
  2192.         zconfout = out_str ;
  2193. }
  2194.  
  2195. int zconfget_debug  (void)
  2196. {
  2197.         return zconf_flex_debug;
  2198. }
  2199.  
  2200. void zconfset_debug (int  bdebug )
  2201. {
  2202.         zconf_flex_debug = bdebug ;
  2203. }
  2204.  
  2205. static int yy_init_globals (void)
  2206. {
  2207.         /* Initialization is the same as for the non-reentrant scanner.
  2208.      * This function is called from zconflex_destroy(), so don't allocate here.
  2209.      */
  2210.  
  2211.     (yy_buffer_stack) = 0;
  2212.     (yy_buffer_stack_top) = 0;
  2213.     (yy_buffer_stack_max) = 0;
  2214.     (yy_c_buf_p) = (char *) 0;
  2215.     (yy_init) = 0;
  2216.     (yy_start) = 0;
  2217.  
  2218. /* Defined in main.c */
  2219. #ifdef YY_STDINIT
  2220.     zconfin = stdin;
  2221.     zconfout = stdout;
  2222. #else
  2223.     zconfin = (FILE *) 0;
  2224.     zconfout = (FILE *) 0;
  2225. #endif
  2226.  
  2227.     /* For future reference: Set errno on error, since we are called by
  2228.      * zconflex_init()
  2229.      */
  2230.     return 0;
  2231. }
  2232.  
  2233. /* zconflex_destroy is for both reentrant and non-reentrant scanners. */
  2234. int zconflex_destroy  (void)
  2235. {
  2236.     
  2237.     /* Pop the buffer stack, destroying each element. */
  2238.     while(YY_CURRENT_BUFFER){
  2239.         zconf_delete_buffer(YY_CURRENT_BUFFER  );
  2240.         YY_CURRENT_BUFFER_LVALUE = NULL;
  2241.         zconfpop_buffer_state();
  2242.     }
  2243.  
  2244.     /* Destroy the stack itself. */
  2245.     zconffree((yy_buffer_stack) );
  2246.     (yy_buffer_stack) = NULL;
  2247.  
  2248.     /* Reset the globals. This is important in a non-reentrant scanner so the next time
  2249.      * zconflex() is called, initialization will occur. */
  2250.     yy_init_globals( );
  2251.  
  2252.     return 0;
  2253. }
  2254.  
  2255. /*
  2256.  * Internal utility routines.
  2257.  */
  2258.  
  2259. #ifndef yytext_ptr
  2260. static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
  2261. {
  2262.     register int i;
  2263.     for ( i = 0; i < n; ++i )
  2264.         s1[i] = s2[i];
  2265. }
  2266. #endif
  2267.  
  2268. #ifdef YY_NEED_STRLEN
  2269. static int yy_flex_strlen (yyconst char * s )
  2270. {
  2271.     register int n;
  2272.     for ( n = 0; s[n]; ++n )
  2273.         ;
  2274.  
  2275.     return n;
  2276. }
  2277. #endif
  2278.  
  2279. void *zconfalloc (yy_size_t  size )
  2280. {
  2281.     return (void *) malloc( size );
  2282. }
  2283.  
  2284. void *zconfrealloc  (void * ptr, yy_size_t  size )
  2285. {
  2286.     /* The cast to (char *) in the following accommodates both
  2287.      * implementations that use char* generic pointers, and those
  2288.      * that use void* generic pointers.  It works with the latter
  2289.      * because both ANSI C and C++ allow castless assignment from
  2290.      * any pointer type to void*, and deal with argument conversions
  2291.      * as though doing an assignment.
  2292.      */
  2293.     return (void *) realloc( (char *) ptr, size );
  2294. }
  2295.  
  2296. void zconffree (void * ptr )
  2297. {
  2298.     free( (char *) ptr );    /* see zconfrealloc() for (char *) cast */
  2299. }
  2300.  
  2301. #define YYTABLES_NAME "yytables"
  2302.  
  2303. void zconf_starthelp(void)
  2304. {
  2305.     new_string();
  2306.     last_ts = first_ts = 0;
  2307.     BEGIN(HELP);
  2308. }
  2309.  
  2310. static void zconf_endhelp(void)
  2311. {
  2312.     zconflval.string = text;
  2313.     BEGIN(INITIAL);
  2314. }
  2315.  
  2316. /*
  2317.  * Try to open specified file with following names:
  2318.  * ./name
  2319.  * $(srctree)/name
  2320.  * The latter is used when srctree is separate from objtree
  2321.  * when compiling the kernel.
  2322.  * Return NULL if file is not found.
  2323.  */
  2324. FILE *zconf_fopen(const char *name)
  2325. {
  2326.     char *env, fullname[PATH_MAX+1];
  2327.     FILE *f;
  2328.  
  2329.     f = fopen(name, "r");
  2330.     if (!f && name != NULL && name[0] != '/') {
  2331.         env = getenv(SRCTREE);
  2332.         if (env) {
  2333.             sprintf(fullname, "%s/%s", env, name);
  2334.             f = fopen(fullname, "r");
  2335.         }
  2336.     }
  2337.     return f;
  2338. }
  2339.  
  2340. void zconf_initscan(const char *name)
  2341. {
  2342.     zconfin = zconf_fopen(name);
  2343.     if (!zconfin) {
  2344.         printf("can't find file %s\n", name);
  2345.         exit(1);
  2346.     }
  2347.  
  2348.     current_buf = malloc(sizeof(*current_buf));
  2349.     memset(current_buf, 0, sizeof(*current_buf));
  2350.  
  2351.     current_file = file_lookup(name);
  2352.     current_file->lineno = 1;
  2353.     current_file->flags = FILE_BUSY;
  2354. }
  2355.  
  2356. void zconf_nextfile(const char *name)
  2357. {
  2358.     struct file *file = file_lookup(name);
  2359.     struct buffer *buf = malloc(sizeof(*buf));
  2360.     memset(buf, 0, sizeof(*buf));
  2361.  
  2362.     current_buf->state = YY_CURRENT_BUFFER;
  2363.     zconfin = zconf_fopen(name);
  2364.     if (!zconfin) {
  2365.         printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
  2366.         exit(1);
  2367.     }
  2368.     zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
  2369.     buf->parent = current_buf;
  2370.     current_buf = buf;
  2371.  
  2372.     if (file->flags & FILE_BUSY) {
  2373.         printf("recursive scan (%s)?\n", name);
  2374.         exit(1);
  2375.     }
  2376.     if (file->flags & FILE_SCANNED) {
  2377.         printf("file %s already scanned?\n", name);
  2378.         exit(1);
  2379.     }
  2380.     file->flags |= FILE_BUSY;
  2381.     file->lineno = 1;
  2382.     file->parent = current_file;
  2383.     current_file = file;
  2384. }
  2385.  
  2386. static void zconf_endfile(void)
  2387. {
  2388.     struct buffer *parent;
  2389.  
  2390.     current_file->flags |= FILE_SCANNED;
  2391.     current_file->flags &= ~FILE_BUSY;
  2392.     current_file = current_file->parent;
  2393.  
  2394.     parent = current_buf->parent;
  2395.     if (parent) {
  2396.         fclose(zconfin);
  2397.         zconf_delete_buffer(YY_CURRENT_BUFFER);
  2398.         zconf_switch_to_buffer(parent->state);
  2399.     }
  2400.     free(current_buf);
  2401.     current_buf = parent;
  2402. }
  2403.  
  2404. int zconf_lineno(void)
  2405. {
  2406.     return current_pos.lineno;
  2407. }
  2408.  
  2409. char *zconf_curname(void)
  2410. {
  2411.     return current_pos.file ? current_pos.file->name : "<none>";
  2412. }
  2413.  
  2414.